package BasicEngine
{
	import flash.events.Event;
	import flash.utils.Dictionary;

	//消息管理器
	public class MsgManager
	{
		//全局消息处理表
		//当发送不指明接收者的消息（全局消息),这个表里的实体都会响应 这里存储的是一个String -- Vector.<int>
		public static var GlobalProcEnts:Dictionary;		
		
		public function MsgManager()
		{
			//构造函数			
		}
		
		//初始化
		public static function Init():void
		{
			GlobalProcEnts = new Dictionary();
		}
		
		//给实体注册消息处理函数
		//默认注册的不是全局消息
		public static function RegistEntProc(_ent:Entity,_procMin:String, _proc:Function, _global:Boolean = false):void
		{
			if (_ent.MsgProcTable.indexOf(_proc) == -1)//防止重复注册
			{
				var i:int = _ent.MsgProcTable.push(_proc) -1;  //索引值（执行ID）
				_ent.MsgIndexTable[_procMin] = i;
				if (_global)
				     RegistGlobalEntProc(_ent.ID, _procMin);
			}
		}
		
		//给实体注册消息处理函数
		//默认注册的不是全局消息
		public static function RegistIDProc(_entID:int,_procMin:String, _proc:Function, _global:Boolean = false):void
		{
			var ent:Entity = EntityManager.GetEntityByID(_entID);
			if (ent != null)
			     RegistEntProc(ent,_procMin,_proc,_global);
		}
				
		//发送消息（根据ID）
		public static function SendMessage(_msgId:MsgId):void
		{
			SendMessageBase(_msgId);
		}
		
		//发送消息
		//如果消息没有接收者，就表示这是 一个全局消息，指明Msg的接受ID为-1
		public static function SendMessageBase(_msg:Msg):void
		{
			if (_msg.AcceptID == -1)
			{
				if (GlobalProcEnts[_msg.ProcMin] != null)
				{
					for each(var item:Vector.<int> in GlobalProcEnts)
					{
						for each(var entId:int in item)
						{
							var ent:Entity = EntityManager.GetEntityByID(entId);
							if (ent.MsgIndexTable[_msg.ProcMin] == null)
							     return;
							_msg.Accepter = ent;
							var i:int = ent.MsgIndexTable[_msg.ProcMin];
							ent.MsgProcTable[i](_msg);							
						}
					}
				}
			}
			else
			{
				ProcMessage(_msg);
			}
		}
		
		public static function RemoveGlobalProc(_id:int):void
		{
			for each(var item:Vector.<int> in GlobalProcEnts)
				{
					item.splice(0, 1, _id);
				}
		}
		
		//执行消息处理函数
		public static function  ProcMessage(_msg:Msg):void
		{
			var ent:Entity = _msg.Accepter;
			if (ent == null)
			{
				trace("实体为空:", _msg.MsgNote, ":", _msg.AcceptID);
				return;
			}
			if (ent.MsgIndexTable[_msg.ProcMin] == null)
			{
				trace("消息处理为空:",_msg.MsgNote," ID:",_msg.AcceptID);
				return;
			}
			var i:int = ent.MsgIndexTable[_msg.ProcMin];
			ent.MsgProcTable[i](_msg);			 
		}
		
		//给实体注册一个全局消息
		//注意，这个方法，仅仅把实体放入了全局处理表中，并没有真正付给实体消息处理的方法
		public static function RegistGlobalEntProc(_ent:int,_procMin:String):void
		{
			if(GlobalProcEnts[_procMin] != null)     //如果已经存在一个此消息辨识码的序列
			{
				var existProcEnts:Vector.<int> = GlobalProcEnts[_procMin];
				existProcEnts.push(_ent);
			}
			else
			{
				var newProcEnts:Vector.<int> = new Vector.<int>();
				newProcEnts.push(_ent);
				GlobalProcEnts[_procMin] = newProcEnts;
			}			
		}
		
		//从全局处理表中删除不再处理的实体
		public static function RemoveGlobalEntProc(_ent:int):void
		{
			for each(var item:Vector.<int> in GlobalProcEnts)
			{
				var index:int = item.indexOf(_ent);
				item.splice(index,1);
			}
		}			
		
		public static function Compare(x:int,y:int):Number
		{
			return x - y;
		}
		
	}
}